Configuration used: Repository UI

Review profile: CHILL

Plan: Pro

Learnt from: CR
Repo: deepmodeling/deepmd-kit PR: 0
File: AGENTS.md:0-0
Timestamp: 2025-12-12T13:40:14.334Z
Learning: Install and run ruff linter with `uv pip install ruff`, then run `ruff check .` and `ruff format .` before committing changes

Learnt from: CR
Repo: deepmodeling/deepmd-kit PR: 0
File: AGENTS.md:0-0
Timestamp: 2025-12-12T13:40:14.334Z
Learning: Install and run ruff linter with `uv pip install ruff`, then run `ruff check .` and `ruff format .` before committing changes

source/tests/pt/test_utils.py (1)

21-25: Consider using strict=True for better safety.

Since both lists are hardcoded with exactly 3 matching elements, using strict=True would be more appropriate. This would catch accidental modifications where one list is changed but not the other, aligning better with the PR's goal to "prevent issues with zip."

✨ Suggested refactor

         for ptp, npp in zip(
             [torch.float16, torch.float32, torch.float64],
             [np.float16, np.float32, np.float64],
-            strict=False,
+            strict=True,
         ):

deepmd/pt/train/training.py (1)

653-655: Consider using strict=True instead of strict=False.

By construction, self.model_keys and self.model_prob always have matching lengths. Line 626 initializes self.model_prob with exactly len(self.model_keys) elements, and subsequent operations (lines 629-637) only modify values, not the array length. Using strict=True would be more defensive and help catch potential bugs if the initialization logic changes in the future.

🔒 Proposed change to use strict=True

             model_key_prob_map=dict(
-                zip(self.model_keys, self.model_prob, strict=False)
+                zip(self.model_keys, self.model_prob, strict=True)
             ),

deepmd/tf/nvnmd/entrypoints/mapt.py (1)

437-446: Consider using strict=True for better error detection.

The pattern here extracts keys and values from dic_ph, processes the values through run_sess, then reconstructs a dictionary. Since TensorFlow's sess.run() returns results matching the input tensor list, len(keys) should always equal len(res_lst) and len(res_lst2).

Using strict=False silently ignores length mismatches, which could hide serious bugs. Consider using strict=True to fail fast if the invariant is violated:

res_dic = dict(zip(keys, res_lst, strict=True))

The same applies to line 446.

source/tests/consistent/io/test_io.py (2)

212-212: Consider verifying that result lengths match across backends.

Similar to line 205, using strict=False here could hide unexpected length mismatches between backends.

---

205-205: Add explicit documentation or assertion to clarify expected behavior for variable-length backend results.

The code uses strict=False with the NaN handling comment "expect all nan if not supported", suggesting intentional tolerance for backends returning different numbers of results. However, this design choice lacks explicit documentation or assertions.

Consider adding either:

1. A comment explaining that backends may return different lengths when features are unsupported
2. An assertion verifying both iterables match in length when neither is all-NaN

This clarifies whether the silent truncation is intentional protection against unsupported features or a gap in verification.

deepmd/calculator.py (1)

106-106: Consider using strict=True since lengths are guaranteed to match.

Based on the relevant code snippets, get_ntypes() returns len(self.type_map), which means range(self.dp.get_ntypes()) will always have exactly the same length as get_type_map(). Using strict=False is unnecessarily permissive and could mask bugs if these ever get out of sync.

📝 Suggested change

-            zip(self.dp.get_type_map(), range(self.dp.get_ntypes()), strict=False)
+            zip(self.dp.get_type_map(), range(self.dp.get_ntypes()), strict=True)

deepmd/pd/utils/nlist.py (1)

407-407: Consider using strict=True to match the length assertion.

Line 365 contains an assertion assert len(rcuts) == len(nsels) (active only in dynamic mode), indicating that these lists are expected to have matching lengths. Using strict=True would provide consistent length checking in all execution modes and help catch bugs earlier.

📝 Suggested change

-    for rc, ns in zip(rcuts[::-1], nsels[::-1], strict=False):
+    for rc, ns in zip(rcuts[::-1], nsels[::-1], strict=True):

deepmd/pt/model/descriptor/se_a.py (1)

788-793: Consider using strict=True since these lists are initialized with matching lengths.

At lines 550-561, compress_info and compress_data are both initialized as ParameterList with length len(self.filter_layers.networks). Since all three lists are guaranteed to have the same length, using strict=True would help catch any logic errors that might cause them to get out of sync.

📝 Suggested change

         for embedding_idx, (ll, compress_data_ii, compress_info_ii) in enumerate(
             zip(
                 self.filter_layers.networks,
                 self.compress_data,
                 self.compress_info,
-                strict=False,
+                strict=True,
             )
         ):

source/tests/consistent/fitting/test_dipole.py (1)

288-288: Consider verifying that result lengths match across backends.

Using strict=False allows the zip to silently truncate if ret1 and ret2 have different lengths. This could mask bugs where backends unexpectedly return different numbers of results. Consider adding a length assertion before the comparison loop to ensure backends are consistent.

📝 Suggested fix

+        assert len(ret1) == len(ret2), f"Result length mismatch: {len(ret1)} vs {len(ret2)}"
-        for rr1, rr2 in zip(ret1, ret2, strict=False):
+        for rr1, rr2 in zip(ret1, ret2, strict=True):

source/tests/common/dpmodel/test_pairtab_atomic_model.py (1)

128-162: Explicit strict=False correctly preserves existing behavior.

The addition of strict=False makes the zip behavior explicit, satisfying the B905 linting rule while preserving the current non-strict iteration behavior.

Since both input lists have exactly 14 elements and should always remain paired, consider using strict=True instead to catch potential errors if the lists diverge during future modifications:

♻️ Optional refinement

-        for dist, rcut in zip(
-            [
-                0.01,
-                0.015,
-                0.020,
-                0.015,
-                0.02,
-                0.021,
-                0.015,
-                0.02,
-                0.021,
-                0.025,
-                0.026,
-                0.025,
-                0.025,
-                0.0216161,
-            ],
-            [
-                0.015,
-                0.015,
-                0.015,
-                0.02,
-                0.02,
-                0.02,
-                0.022,
-                0.022,
-                0.022,
-                0.025,
-                0.025,
-                0.03,
-                0.035,
-                0.025,
-            ],
-            strict=False,
-        ):
+        for dist, rcut in zip(
+            [
+                0.01,
+                0.015,
+                0.020,
+                0.015,
+                0.02,
+                0.021,
+                0.015,
+                0.02,
+                0.021,
+                0.025,
+                0.026,
+                0.025,
+                0.025,
+                0.0216161,
+            ],
+            [
+                0.015,
+                0.015,
+                0.015,
+                0.02,
+                0.02,
+                0.02,
+                0.022,
+                0.022,
+                0.022,
+                0.025,
+                0.025,
+                0.03,
+                0.035,
+                0.025,
+            ],
+            strict=True,
+        ):

deepmd/pt/model/model/transform_output.py (1)

108-149: Explicit strict=False correctly preserves existing behavior.

The change makes the zip behavior explicit, satisfying the B905 linting rule. Both split_vv1 and split_svv1 are created by splitting with [1] * size (lines 122-123), so they have the same length.

Since both sequences are derived from the same size variable and should always have matching lengths, using strict=True would provide defensive error checking:

♻️ Optional refinement

-    for vvi, svvi in zip(split_vv1, split_svv1, strict=False):
+    for vvi, svvi in zip(split_vv1, split_svv1, strict=True):

source/tests/pd/test_utils.py (1)

21-25: Explicit strict=False correctly preserves existing behavior.

The addition of strict=False satisfies the B905 linting rule while maintaining the current non-strict iteration behavior.

Both lists contain exactly 3 elements and should remain paired. Consider strict=True for better error detection:

♻️ Optional refinement

-        for ptp, npp in zip(
-            [paddle.float16, paddle.float32, paddle.float64],
-            [np.float16, np.float32, np.float64],
-            strict=False,
-        ):
+        for ptp, npp in zip(
+            [paddle.float16, paddle.float32, paddle.float64],
+            [np.float16, np.float32, np.float64],
+            strict=True,
+        ):

deepmd/jax/infer/deep_eval.py (1)

248-254: Explicit strict=False correctly preserves existing behavior.

The change makes the zip behavior explicit, satisfying the B905 linting rule. The results tuple is constructed by iterating over request_defs (lines 381-397), so both sequences should have matching lengths.

Since the results list is built by iterating over the same request_defs, using strict=True would catch programming errors if the sequences inadvertently diverge:

♻️ Optional refinement

         return dict(
             zip(
                 [x.name for x in request_defs],
                 out,
-                strict=False,
+                strict=True,
             )
         )

source/tests/pt/model/test_nlist.py (1)

248-250: Explicit strict=False correctly preserves existing behavior.

The addition of strict=False satisfies the B905 linting rule while preserving the current non-strict iteration behavior.

Both lists contain exactly 2 elements and are meant to be paired for test parameterization. Consider strict=True for better error detection:

♻️ Optional refinement

-        for distinguish_types, mysel in zip(
-            [True, False], [sum(self.nsel), 300], strict=False
-        ):
+        for distinguish_types, mysel in zip(
+            [True, False], [sum(self.nsel), 300], strict=True
+        ):

deepmd/pt/model/descriptor/hybrid.py (1)

98-98: Consider using strict=True to catch potential length mismatches.

While strict=False preserves backward compatibility, start_idx and end_idx should always have the same length based on the construction logic. Using strict=True would catch any bugs where this assumption is violated, making the code more robust.

🔒 Suggested change for stricter validation

-                [range(ss, ee) for ss, ee in zip(start_idx, end_idx, strict=False)]
+                [range(ss, ee) for ss, ee in zip(start_idx, end_idx, strict=True)]

deepmd/pt/optimizer/LKF.py (1)

295-295: Consider using strict=True for safer parameter updates.

Both tmp_grad and tmp are produced by __split_weights() applied to the gradient and parameter of the same tensor, so they should always have matching lengths. Using strict=True would catch any logic errors in the splitting process, which is particularly important in optimizer code where silent bugs could corrupt training.

🔒 Suggested change for stricter validation

-            for split_grad, split_weight in zip(tmp_grad, tmp, strict=False):
+            for split_grad, split_weight in zip(tmp_grad, tmp, strict=True):

deepmd/pd/infer/deep_eval.py (1)

384-389: Consider using strict=True to ensure all outputs are returned.

The output dictionary is constructed by zipping output names from request_defs with results from _eval_model. These should always have matching lengths by design. Using strict=True would immediately catch any bugs where the number of outputs doesn't match expectations, rather than silently dropping outputs, which could lead to confusing missing keys in the returned dictionary.

🔒 Suggested change for stricter validation

         return dict(
             zip(
                 [x.name for x in request_defs],
                 out,
-                strict=False,
+                strict=True,
             )
         )

source/tests/pt/model/test_pairtab_atomic_model.py (1)

189-223: Consider using strict=True for safer zip behavior.

The two lists being zipped (lines 190-221) both contain exactly 14 elements and are designed to be paired together for testing various distance/rcut combinations. If these lists were to have mismatched lengths due to a coding error, using strict=True would immediately catch the bug rather than silently truncating to the shorter list.

✨ Suggested change

-        for dist, rcut in zip(
-            [
-                0.01,
-                0.015,
-                0.020,
-                0.015,
-                0.02,
-                0.021,
-                0.015,
-                0.02,
-                0.021,
-                0.025,
-                0.026,
-                0.025,
-                0.025,
-                0.0216161,
-            ],
-            [
-                0.015,
-                0.015,
-                0.015,
-                0.02,
-                0.02,
-                0.02,
-                0.022,
-                0.022,
-                0.022,
-                0.025,
-                0.025,
-                0.03,
-                0.035,
-                0.025,
-            ],
-            strict=False,
-        ):
+        for dist, rcut in zip(
+            [
+                0.01,
+                0.015,
+                0.020,
+                0.015,
+                0.02,
+                0.021,
+                0.015,
+                0.02,
+                0.021,
+                0.025,
+                0.026,
+                0.025,
+                0.025,
+                0.0216161,
+            ],
+            [
+                0.015,
+                0.015,
+                0.015,
+                0.02,
+                0.02,
+                0.02,
+                0.022,
+                0.022,
+                0.022,
+                0.025,
+                0.025,
+                0.03,
+                0.035,
+                0.025,
+            ],
+            strict=True,
+        ):

source/tests/tf/test_linear_model.py (1)

40-41: Consider using strict=True since the lists are guaranteed to have matching lengths.

Line 39 shows that self.graph_dirs is derived from self.pbtxts via list comprehension, ensuring they always have identical lengths. Using strict=True would provide better error detection if future refactoring accidentally breaks this relationship.

✨ Suggested change

-        for pbtxt, pb in zip(self.pbtxts, self.graph_dirs, strict=False):
+        for pbtxt, pb in zip(self.pbtxts, self.graph_dirs, strict=True):
             convert_pbtxt_to_pb(pbtxt, pb)

deepmd/pd/model/model/transform_output.py (1)

125-134: Consider using strict=True to ensure split operations produce matching chunks.

Lines 122-123 show both tensors are split using the same pattern [1] * size, which should produce equal-length lists. If the lengths differ, it indicates a serious issue with the tensor shapes or split operation. Using strict=True would catch such errors immediately rather than silently processing mismatched data.

✨ Suggested change

-    for vvi, svvi in zip(split_vv1, split_svv1, strict=False):
+    for vvi, svvi in zip(split_vv1, split_svv1, strict=True):
         # nf x nloc x 3, nf x nloc x 9
         ffi, aviri = task_deriv_one(
             vvi,
             svvi,
             coord_ext,
             do_virial=do_virial,
             do_atomic_virial=do_atomic_virial,
             create_graph=create_graph,
         )

deepmd/pt/model/descriptor/se_t.py (1)

847-854: Consider using strict=True to validate model structure consistency.

The three collections being zipped are initialized with matching lengths (lines 598-609): compress_info and compress_data are both created with range(len(self.filter_layers.networks)). If these lengths were to differ, it would indicate model corruption or an initialization bug. Using strict=True would catch such structural issues immediately during the forward pass.

✨ Suggested change

         for embedding_idx, (ll, compress_data_ii, compress_info_ii) in enumerate(
             zip(
                 self.filter_layers.networks,
                 self.compress_data,
                 self.compress_info,
-                strict=False,
+                strict=True,
             )
         ):

deepmd/dpmodel/infer/deep_eval.py (1)

228-234: Consider using strict=True to catch output mismatches.

The strict=False preserves backward compatibility, but using strict=True would catch logic errors where the number of output definitions doesn't match the number of results returned by the model.

🔧 Suggested improvement

         return dict(
             zip(
                 [x.name for x in request_defs],
                 out,
-                strict=False,
+                strict=True,
             )
         )

deepmd/dpmodel/utils/nlist.py (1)

237-237: Consider strict=True for consistency with the length assertion.

Since line 216 asserts len(rcuts) == len(nsels), using strict=True would provide redundant validation and a clearer error context if the assertion is somehow bypassed or if the assertion is removed in the future.

🔧 Suggested improvement

-    for rc, ns in zip(rcuts[::-1], nsels[::-1], strict=False):
+    for rc, ns in zip(rcuts[::-1], nsels[::-1], strict=True):

deepmd/pt/model/descriptor/se_r.py (1)

498-505: Consider strict=True to catch initialization issues.

The three iterables (filter_layers.networks, compress_data, compress_info) are initialized with the same length (lines 157-168). Using strict=True would detect any initialization bugs where the lengths diverge.

🔧 Suggested improvement

         for ii, (ll, compress_data_ii, compress_info_ii) in enumerate(
             zip(
                 self.filter_layers.networks,
                 self.compress_data,
                 self.compress_info,
-                strict=False,
+                strict=True,
             )
         ):

deepmd/pt/utils/nlist.py (1)

401-401: Consider strict=True for consistency with the length assertion.

Since line 366 asserts len(rcuts) == len(nsels), using strict=True would provide redundant validation and a clearer error context if the lengths somehow become mismatched.

🔧 Suggested improvement

-    for rc, ns in zip(rcuts[::-1], nsels[::-1], strict=False):
+    for rc, ns in zip(rcuts[::-1], nsels[::-1], strict=True):

deepmd/pd/model/descriptor/se_a.py (1)

765-771: Consider using strict=True instead of strict=False.

The three iterables (self.filter_layers.networks, self.compress_data, self.compress_info) are constructed together in __init__ (lines 525-536) with matching lengths. Using strict=False silently truncates to the shortest iterable if a programming error causes length mismatches, potentially masking bugs. Since equal lengths are expected, strict=True would catch such errors early.

🔍 Suggested change

-        for embedding_idx, (ll, compress_data_ii, compress_info_ii) in enumerate(
-            zip(
-                self.filter_layers.networks,
-                self.compress_data,
-                self.compress_info,
-                strict=False,
-            )
-        ):
+        for embedding_idx, (ll, compress_data_ii, compress_info_ii) in enumerate(
+            zip(
+                self.filter_layers.networks,
+                self.compress_data,
+                self.compress_info,
+                strict=True,
+            )
+        ):

deepmd/dpmodel/descriptor/hybrid.py (2)

104-104: Use strict=True for this zip call.

start_idx and end_idx are computed from the same hybrid_sel array (lines 101-102), so they are guaranteed to have the same length. Using strict=True would detect any future programming errors that violate this invariant.

🔍 Suggested change

             cut_idx = np.concatenate(
-                [range(ss, ee) for ss, ee in zip(start_idx, end_idx, strict=False)]
+                [range(ss, ee) for ss, ee in zip(start_idx, end_idx, strict=True)]
             )

---

313-313: Use strict=True for this zip call.

self.nlist_cut_idx is constructed with exactly one entry per descriptor in the loop at lines 94-106, so it should always have the same length as self.descrpt_list. Using strict=True ensures this invariant is maintained and catches bugs early.

🔍 Suggested change

-        for descrpt, nci in zip(self.descrpt_list, self.nlist_cut_idx, strict=False):
+        for descrpt, nci in zip(self.descrpt_list, self.nlist_cut_idx, strict=True):

source/tests/consistent/common.py (1)

358-358: Use strict=True in test comparison loops to catch backend inconsistencies.

These zip calls compare results from different backend implementations (TF, PT, DP, JAX, PD, array_api_strict). If backends return different numbers of results, that indicates an implementation bug. Using strict=False silently masks such inconsistencies by only comparing the overlapping elements. Use strict=True to ensure all backends produce the same number of outputs.

🔍 Example fix for line 358

-        for rr1, rr2 in zip(ret1, ret2, strict=False):
+        for rr1, rr2 in zip(ret1, ret2, strict=True):

Apply the same change to all similar zip calls in this file (lines 375, 394, 410, 439, 452, 476, 489, 518, 531, 553, 567).

Also applies to: 375-375, 394-394, 410-410, 439-439, 452-452, 476-476, 489-489, 518-518, 531-531, 553-553, 567-567

deepmd/tf/descriptor/se_atten.py (2)

381-389: Use strict=True for data integrity checking.

The parallel data arrays (data_coord, data_box, data_atype, natoms_vec, mesh, real_natoms_vec) represent the same batch of frames and should always have matching lengths. Using strict=False allows silent data corruption if these arrays somehow become misaligned. Use strict=True to validate data integrity.

🔍 Suggested change

                 for cc, bb, tt, nn, mm, r_n in zip(
                     data_coord,
                     data_box,
                     data_atype,
                     natoms_vec,
                     mesh,
                     real_natoms_vec,
-                    strict=False,
+                    strict=True,
                 ):

---

400-401: Use strict=True for data integrity checking.

The parallel data arrays (data_coord, data_box, data_atype, natoms_vec, mesh) represent the same batch of frames and should always have matching lengths. Using strict=False allows silent data corruption if these arrays become misaligned. Use strict=True to validate data integrity.

🔍 Suggested change

                 for cc, bb, tt, nn, mm in zip(
-                    data_coord, data_box, data_atype, natoms_vec, mesh, strict=False
+                    data_coord, data_box, data_atype, natoms_vec, mesh, strict=True
                 ):

deepmd/utils/data_system.py (1)

175-177: Use strict=True to maintain invariant between system_dirs and data_systems.

self.system_dirs and self.data_systems are constructed together in __init__ (lines 100-117), with one DeepmdData object created for each system directory. They should always have the same length. Using strict=False allows silent bugs if this invariant is violated. Use strict=True to catch such programming errors early.

🔍 Suggested change

                 for sys_dir, data_sys in zip(
-                    self.system_dirs, self.data_systems, strict=False
+                    self.system_dirs, self.data_systems, strict=True
                 ):

deepmd/dpmodel/atomic_model/linear_atomic_model.py (3)

157-161: Consider using strict=True for added safety.

The iterables self.get_model_rcuts() and self.get_model_nsels() both derive from self.models, so they should always have the same length. Using strict=True would help catch bugs if these lists ever become desynchronized.

Proposed change

         zipped = sorted(
-            zip(self.get_model_rcuts(), self.get_model_nsels(), strict=False),
+            zip(self.get_model_rcuts(), self.get_model_nsels(), strict=True),
             key=lambda x: (x[1], x[0]),
         )

---

236-241: Consider using strict=True for added safety.

The iterables self.get_model_rcuts() and self.get_model_nsels() both derive from self.models, so they should always have the same length. Using strict=True would help catch bugs if these lists ever become desynchronized.

Proposed change

         raw_nlists = [
             nlists[get_multiple_nlist_key(rcut, sel)]
-            for rcut, sel in zip(
-                self.get_model_rcuts(), self.get_model_nsels(), strict=False
-            )
+            for rcut, sel in zip(
+                self.get_model_rcuts(), self.get_model_nsels(), strict=True
+            )
         ]

---

242-247: Consider using strict=True for added safety.

The iterables self.mixed_types_list, raw_nlists, and self.get_model_sels() all derive from self.models and should have the same length. Using strict=True would help catch bugs if these lists ever become desynchronized.

Proposed change

         nlists_ = [
             nl if mt else nlist_distinguish_types(nl, extended_atype, sel)
             for mt, nl, sel in zip(
-                self.mixed_types_list, raw_nlists, self.get_model_sels(), strict=False
+                self.mixed_types_list, raw_nlists, self.get_model_sels(), strict=True
             )
         ]

source/tests/pt/model/test_descriptor_se_r.py (1)

103-110: Optional: Consider using strict=True for test robustness.

The zip iterates over two fixed-length lists [rd1, sw1] and [rd2, sw2], both containing exactly 2 elements. Using strict=True would be more explicit and protect against future modifications that might introduce length mismatches.

Proposed change

-            for aa, bb in zip([rd1, sw1], [rd2, sw2], strict=False):
+            for aa, bb in zip([rd1, sw1], [rd2, sw2], strict=True):
                 np.testing.assert_allclose(
                     aa.detach().cpu().numpy(),
                     bb,

deepmd/tf/descriptor/se_r.py (1)

273-275: Consider using strict=True to validate data alignment.

The zip iterates over training data arrays (data_coord, data_box, data_atype, natoms_vec, mesh) that should all have the same length (representing the same number of systems or frames). Using strict=False will silently process only up to the shortest array, potentially hiding data corruption or misalignment issues. Using strict=True would catch such problems early during statistics computation.

Proposed change

         for cc, bb, tt, nn, mm in zip(
-            data_coord, data_box, data_atype, natoms_vec, mesh, strict=False
+            data_coord, data_box, data_atype, natoms_vec, mesh, strict=True
         ):

Configuration used: Repository UI

Review profile: CHILL

Plan: Pro

Learnt from: njzjz
Repo: deepmodeling/deepmd-kit PR: 4160
File: deepmd/dpmodel/utils/env_mat.py:52-64
Timestamp: 2024-10-08T15:32:11.479Z
Learning: Negative indices in `nlist` are properly handled by masking later in the computation, so they do not cause issues in indexing operations.

Learnt from: njzjz
Repo: deepmodeling/deepmd-kit PR: 4144
File: source/api_cc/tests/test_deeppot_dpa_pt.cc:166-246
Timestamp: 2024-10-08T15:32:11.479Z
Learning: Refactoring between test classes `TestInferDeepPotDpaPt` and `TestInferDeepPotDpaPtNopbc` is addressed in PR #3905.

pyproject.toml (1)

433-435: Consider tracking the B905 exceptions as technical debt.

The exceptions for deepmd/pt/** and deepmd/pd/** are a pragmatic approach for migrating a large codebase. However, for consistency and clarity, it would be beneficial to eventually add explicit strict=False (or strict=True where appropriate) to zip() calls in these directories as well.

Would you like me to open an issue to track removing these exceptions in a future PR?

Configuration used: Repository UI

Review profile: CHILL

Plan: Pro

Learnt from: njzjz
Repo: deepmodeling/deepmd-kit PR: 4284
File: deepmd/jax/__init__.py:8-8
Timestamp: 2024-10-30T20:08:12.531Z
Learning: In the DeepMD project, entry points like `deepmd.jax` may be registered in external projects, so their absence in the local configuration files is acceptable.

Configuration used: Repository UI

Review profile: CHILL

Plan: Pro

pyproject.toml (1)

434-436: Document the rationale for selectively ignoring B905 in pt and pd backends.

B905 is ignored for deepmd/pt/** and deepmd/pd/** but enforced for deepmd/tf/** and deepmd/jax/**. This asymmetry appears intentional (pt has 14 zip() calls, pd has 6, while tf enforces B905 despite having 15 zip() calls). Add an inline comment in pyproject.toml explaining why PyTorch and Paddle backends exclude B905 while TensorFlow and JAX enforce it—for example, whether these backends have intentional zip truncation behavior or refactoring constraints that justify the exclusion.

Configuration used: Repository UI

Review profile: CHILL

Plan: Pro

Learnt from: CR
Repo: deepmodeling/deepmd-kit PR: 0
File: AGENTS.md:0-0
Timestamp: 2025-12-12T13:40:14.334Z
Learning: Install and run ruff linter with `uv pip install ruff`, then run `ruff check .` and `ruff format .` before committing changes

Learnt from: CR
Repo: deepmodeling/deepmd-kit PR: 0
File: AGENTS.md:0-0
Timestamp: 2025-12-12T13:40:14.334Z
Learning: Always run `ruff check . && ruff format .` before committing changes to ensure CI passes

Learnt from: njzjz
Repo: deepmodeling/deepmd-kit PR: 4284
File: deepmd/jax/__init__.py:8-8
Timestamp: 2024-10-30T20:08:12.531Z
Learning: In the DeepMD project, entry points like `deepmd.jax` may be registered in external projects, so their absence in the local configuration files is acceptable.